package com.atguigu.gmall.cart.service.impl;

import com.atguigu.gmall.cart.mapper.CartInfoMapper;
import com.atguigu.gmall.cart.service.CartInfoService;
import com.atguigu.gmall.model.cart.CartInfo;
import com.atguigu.gmall.model.product.SkuInfo;
import com.atguigu.gmall.product.client.ProductClientFeign;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Author BrookPeng
 * @Date 2020/12/5 0:44
 * @Version 1.0
 */
@Service
public class CartInfoServiceImpl implements CartInfoService {

    @Autowired
    private CartInfoMapper cartInfoMapper;
    @Autowired
    private ProductClientFeign productClientFeign;

    // 加入购物车
    @Override
    public CartInfo addCart(Long skuId, Integer skuNum, String userId) {

        // 1:先查询当前用户的购物车集合
        QueryWrapper<CartInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        List<CartInfo> cartInfos = cartInfoMapper.selectList(queryWrapper);
        if (!CollectionUtils.isEmpty(cartInfos)) {
            // 2:判断当前正要添加的商品在购物车中是否存在
            boolean alreadyInCart = false;
            for (CartInfo cartInfo : cartInfos) {
                if (cartInfo.getSkuId().equals(skuId)) {
                    // 3:存在 追加商品数量
                    cartInfo.setSkuNum(cartInfo.getSkuNum() + skuNum);
                    // 更改状态为选中
                    cartInfo.setIsChecked(1);
                    alreadyInCart = true;
                    // 更新数据库
                    cartInfoMapper.updateById(cartInfo);
                    return cartInfo;
                }
            }
        }
        // 4:不存在 当作新商品添加到购物车
        CartInfo cartInfo = new CartInfo();
        // 用户ID
        cartInfo.setUserId(userId);
        // 库存商品ID
        cartInfo.setSkuId(skuId);
        // 库存数量
        cartInfo.setSkuNum(skuNum);
        // 购物车价格(商品第一次加入购物车时候的价格)
        // 查询商品实时价格(远程调用商品微服务)
        SkuInfo skuInfo = productClientFeign.getSkuInfo(skuId);
        // 价格
        cartInfo.setCartPrice(skuInfo.getPrice());
        // 图片
        cartInfo.setImgUrl(skuInfo.getSkuDefaultImg());
        // 名称
        cartInfo.setSkuName(skuInfo.getSkuName());
        // 选中
        cartInfo.setIsChecked(1);
        cartInfoMapper.insert(cartInfo);
        // 返回值 当前购物车
        return cartInfo;
    }

    // 查询购物车列表集合
    @Override
    public List<CartInfo> cartList(String userTempId, String userId) {

        List<CartInfo> cartInfos = null;
        // 用户未登录
        if (StringUtils.isEmpty(userId)) {
            // 1.查询临时用户购物车集合
            cartInfos = findCartInfo(userTempId);
        } else {
            // 2.是否拥有临时账户
            if (StringUtils.isEmpty(userTempId)) {
                // 3.查询临时用户购物车集合
                cartInfos = findCartInfo(userId);
            } else {
                // 4.查询登陆用户和临时用户的购物车集合并合并
                cartInfos = mergeCartInfoList(userTempId, userId);
            }
        }
        return cartInfos;
    }

    @Override
    public void checkCart(Long skuId, Integer isChecked, String userId) {

        CartInfo cartInfo = new CartInfo();
        cartInfo.setIsChecked(isChecked);
        QueryWrapper<CartInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        queryWrapper.eq("sku_id", skuId);
        cartInfoMapper.update(cartInfo, queryWrapper);
    }

    // 商品清单
    @Override
    public List<CartInfo> getCartCheckedList(String userId) {

        QueryWrapper<CartInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("is_checked", 1);
        queryWrapper.eq("user_id", userId);
        List<CartInfo> cartInfos = cartInfoMapper.selectList(queryWrapper);
        // 更新缓存中的价格为实时价格
        if (!CollectionUtils.isEmpty(cartInfos)) {
            // 实时价格更新
            cartInfos.forEach((cartInfo -> {
                cartInfo.setSkuPrice(productClientFeign.getPrice(cartInfo.getSkuId()));
            }));
        }
        return cartInfos;
    }

    // 查询登陆用户和临时用户的购物车集合并合并
    private List<CartInfo> mergeCartInfoList(String userTempId, String userId) {

        // 查询登陆用户ID的购物车集合
        List<CartInfo> cartInfosByUserTempId = findCartInfo(userTempId);
        // 查询临时用户ID的购物车集合
        List<CartInfo> cartInfosByUserId = findCartInfo(userId);

        if (CollectionUtils.isEmpty(cartInfosByUserId)) {
            // 临时用户ID的购物车集合不为空的场合 更新临时用户ID的购物车集合 成为登陆用户的购物车集合
            if (!CollectionUtils.isEmpty(cartInfosByUserTempId)) {
                CartInfo cartInfo = new CartInfo();
                cartInfo.setUserId(userId);
                QueryWrapper<CartInfo> queryWrapper = new QueryWrapper<>();
                queryWrapper.eq("user_id", userTempId);
                cartInfoMapper.update(cartInfo, queryWrapper);
            }
            // 返回购物车集合的内容给页面回显
            return cartInfosByUserTempId;
        } else {
            // 登陆用户ID的购物车集合不为空的场合
            if (CollectionUtils.isEmpty(cartInfosByUserTempId)) {
                // 返回登陆用户ID的购物车集合用于页面回显
                return cartInfosByUserId;
            } else {
                // 将登陆用户的购物车集合转换为Map类型用于判断SkuId K:skuId V:CartInfo
                Map<Long, CartInfo> cartInfoByUserIdMap = cartInfosByUserId.stream().collect(
                        Collectors.toMap(CartInfo::getSkuId, (cartInfoByUserId -> {
                            return cartInfoByUserId;
                        })));
                // 合并登陆用户ID与临时用于ID的购物车集合并返回给页面回显
                // 集合的合并 常用操作
                cartInfosByUserTempId.forEach((cartInfoByUserTempId) -> {
                    CartInfo cartInfoByUserId = cartInfoByUserIdMap.get(cartInfoByUserTempId.getSkuId());
                    if (cartInfoByUserId != null) {
                        // 登陆用户购物车集合存在相同商品
                        // 追加该商品在临时购物车集合中的数量
                        cartInfoByUserId.setSkuNum(cartInfoByUserId.getSkuNum() + cartInfoByUserTempId.getSkuNum());
                        // 选中项
                        cartInfoByUserId.setIsChecked(1);
                        // 更新DB
                        // update登陆用户ID购物车中条目
                        cartInfoMapper.updateById(cartInfoByUserId);
                        // delete临时用户ID购物车中条目
                        cartInfoMapper.deleteById(cartInfoByUserTempId.getId());
                    } else {
                        // 登陆用户购物车集合不存在相同商品
                        cartInfoByUserIdMap.put(cartInfoByUserTempId.getSkuId(), cartInfoByUserTempId);
                        // 更新DB
                        // update临时用户ID购物车中条目
                        cartInfoByUserTempId.setUserId(userId);
                        cartInfoMapper.updateById(cartInfoByUserTempId);
                    }
                });
                return new ArrayList<>(cartInfoByUserIdMap.values());
            }
        }
    }

    // 根据用户ID查询购物车
    private List<CartInfo> findCartInfo(String userId) {

        // 从缓存中查
        QueryWrapper<CartInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        List<CartInfo> cartInfos = cartInfoMapper.selectList(queryWrapper);

        // 更新缓存中的价格为实时价格
        if (!CollectionUtils.isEmpty(cartInfos)) {
            // 实时价格更新
            cartInfos.forEach((cartInfo -> {
                cartInfo.setSkuPrice(productClientFeign.getPrice(cartInfo.getSkuId()));
            }));
        }

        return cartInfos;
    }
}